package jzlb

import (
	"encoding/json"
	"errors"
	"os"
	"time"

	//"fmt"
	"sort"
	"strconv"
	"strings"
	"sync"
)

type Jzb_键值表 struct {
	原始数据 map[string]any
	读写许可 *sync.RWMutex
	初始化  bool
}

func (键值类 *Jzb_键值表) Kqxcaq_开启线程安全() {
	if 键值类.读写许可 == nil {
		var 锁 sync.RWMutex
		键值类.读写许可 = &锁
	}
}

func (键值类 *Jzb_键值表) 初始化map() {

	if 键值类.读写许可 != nil {
		键值类.读写许可.Lock()
		defer 键值类.读写许可.Unlock()
	}

	if !键值类.初始化 {
		键值类.原始数据 = make(map[string]any)
		键值类.初始化 = true
	}
}
func New_键值表(是否_线程安全 ...bool) (返回_键值表 Jzb_键值表) {
	返回_键值表.Qk_清空()
	if len(是否_线程安全) > 0 && 是否_线程安全[0] {
		返回_键值表.Kqxcaq_开启线程安全()
	}
	return
}

// 自己通过无限的 键 值 对创建
// string 类型的键
// 基本类型的 值
func Cjjzb_创建键值表(键值 ...any) (返回_键值表 Jzb_键值表, 返回_错误 error) {
	返回_错误 = 返回_键值表.Cj_创建(键值...)
	return
}
func Cjjzb_创建键值表_线程安全(键值 ...any) (返回_键值表 Jzb_键值表, 返回_错误 error) {
	返回_键值表.Kqxcaq_开启线程安全()
	返回_错误 = 返回_键值表.Cj_创建(键值...)
	return
}

func (键值类 *Jzb_键值表) Cj_创建(键值 ...any) (返回_错误 error) {
	键值类.初始化map()
	if len(键值)%2 != 0 {
		返回_错误 = errors.New("错误:键值必须为一键 一值 的 双数")
	}
	键值类.原始数据 = make(map[string]any)
	var 键 string
	for i, v := range 键值 {
		if (i+1)%2 != 0 {
			switch 当前值 := v.(type) {
			case string:
				键 = 当前值
			default:
				返回_错误 = errors.New("错误:键值必须为 string")
				return
			}
		} else {
			返回_错误 = 键值类.Zz_置值(v, 键)
			if 返回_错误 != nil {
				return
			}
		}

	}
	return
}

func (键值类 *Jzb_键值表) Lxfz_连续赋值(键值 ...any) (返回_错误 error) {
	键值类.初始化map()
	if len(键值)%2 != 0 {
		返回_错误 = errors.New("错误:键值必须为一键 一值 的 双数")
	}
	var 键 string
	for i, v := range 键值 {
		if (i+1)%2 != 0 {
			switch 当前值 := v.(type) {
			case string:
				键 = 当前值
			default:
				返回_错误 = errors.New("错误:键值必须为 string")
				return
			}
		} else {
			返回_错误 = 键值类.Zz_置值(v, 键)
			if 返回_错误 != nil {
				return
			}
		}
	}
	return
}
func (键值类 *Jzb_键值表) Cjsonzr_重JSON载入(JSON文本 string) (返回_错误 error) {
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.Lock()
		defer 键值类.读写许可.Unlock()
	}
	返回_错误 = json.Unmarshal([]byte(JSON文本), &键值类.原始数据)
	return
}

// 将当前数据内的 time.time  时间类型  和 []byte 字节集 自动转换成 文本格式
func (键值类 *Jzb_键值表) Gsxz_格式修整() (返回_结果 bool) {
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.Lock()
		defer 键值类.读写许可.Unlock()
	}
	转换表 := 切片和map深拷贝json前byte组处理(键值类.原始数据)
	键值类.原始数据, 返回_结果 = 转换表.(map[string]any)
	return
}
func (键值类 *Jzb_键值表) Cmapzr_重map载入(map表 map[string]any) (返回_错误 error) {
	键值类.初始化map()
	返回_错误 = 切片和map值类型筛选(map表)
	if 返回_错误 != nil {
		return
	}
	if 键值类.读写许可 != nil {
		键值类.读写许可.Lock()
		defer 键值类.读写许可.Unlock()
	}
	键值类.原始数据 = make(map[string]any)
	新map表, _ := q_切片和map深拷贝(map表)
	键值类.原始数据 = 新map表.(map[string]any)
	return
}
func (键值类 *Jzb_键值表) Cjzb_重键值表_安全载入(键值表 Jzb_键值表) {
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.Lock()
		defer 键值类.读写许可.Unlock()
	}
	键值类.原始数据 = 键值表.Dmap_到map()
}
func (键值类 *Jzb_键值表) Qk_清空() bool {
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.Lock()
		defer 键值类.读写许可.Unlock()
	}
	键值类.原始数据 = make(map[string]any)
	return true
}
func (键值类 *Jzb_键值表) Djson_到JSON() (返回_值 string) {
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.RLock()
		defer 键值类.读写许可.RUnlock()
	}
	转换表 := 切片和map深拷贝json前byte组处理(键值类.原始数据)
	JSON, err := json.Marshal(转换表)
	if err != nil {
		返回_值 = "{}"
		return
	}
	返回_值 = string(JSON)
	return
}
func (键值类 *Jzb_键值表) Dmap_到map() (返回_值 map[string]any) {
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.RLock()
		defer 键值类.读写许可.RUnlock()
	}
	新map表, _ := q_切片和map深拷贝(键值类.原始数据)
	返回_值, _ = 新map表.(map[string]any)
	return
}

func (键值类 *Jzb_键值表) Aqkld_安全克隆到_键值表() (返回_值 Jzb_键值表) {
	返回_值.Qk_清空()
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.RLock()
		defer 键值类.读写许可.RUnlock()
	}
	返回_值.Cmapzr_重map载入(键值类.原始数据)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Qz_取值(路径或索引 string, 索引 ...string) (返回_值 any, 返回_错误 error) {
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.RLock()
		defer 键值类.读写许可.RUnlock()
	}
	路径 := ""
	if len(索引) > 0 {
		路径 = 路径或索引 + "." + strings.Join(索引, ".")
	} else {
		路径 = 路径或索引
	}
	路径组 := q_切片和map路径分割(路径)
	if len(路径组) == 0 {
		返回_错误 = errors.New("错误:路径解析错误,路径不能为空")
		return
	}
	返回_值, 返回_错误 = q_切片和map取值(键值类.原始数据, 路径组)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Qwb_取文本(路径或索引 string, 索引 ...string) (返回_值 string) {
	值, 返回_错误 := 键值类.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	返回_值 = any_到文本(值)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Qzs_取整数(路径或索引 string, 索引 ...string) (返回_值 int) {
	值, 返回_错误 := 键值类.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	文本值 := any_到文本(值)
	位置 := strings.Index(文本值, ".")
	if 位置 != -1 {
		文本值 = 文本值[:位置]
	}
	结果, err := strconv.ParseInt(文本值, 0, 64)
	if err != nil {
		//返回_错误 = err
		return
	}
	返回_值 = int(结果)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Qsjdxs_取双精度小数(路径或索引 string, 索引 ...string) (返回_值 float64) {
	值, 返回_错误 := 键值类.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	文本值 := any_到文本(值)
	返回_值, _ = strconv.ParseFloat(文本值, 64)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Qljz_取逻辑值(路径或索引 string, 索引 ...string) (返回_值 bool) {
	值, 返回_错误 := 键值类.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	文本值 := any_到文本(值)
	返回_值, _ = strconv.ParseBool(文本值)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Qmap_取map(路径或索引 string, 索引 ...string) (返回_值 map[string]any) {
	值, 返回_错误 := 键值类.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case map[string]any:
		返回_值 = 当前值
		return
	default:
		//返回_错误 = errors.New("错误:被取值的类型不是map[string]any")
		return
	}
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Qjzb_取键值表(路径或索引 string, 索引 ...string) (返回_值 Jzb_键值表) {
	返回_值.Qk_清空()
	值, 返回_错误 := 键值类.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case map[string]any:
		返回_值.Cmapzr_重map载入(当前值)
		return
	default:
		//返回_错误 = errors.New("错误:被取值的类型不是map[string]any")
		return
	}
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Qqp_取切片(路径或索引 string, 索引 ...string) (返回_值 []any) {
	值, 返回_错误 := 键值类.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case []any:
		返回_值 = 当前值
		return
	default:
		//返回_错误 = errors.New("错误:被取值的类型不是[]any")
		return
	}
}

func (键值类 *Jzb_键值表) Qlb_取列表(路径或索引 string, 索引 ...string) (返回_值 Lb_列表) {
	返回_值.Qk_清空()
	值, 返回_错误 := 键值类.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case []any:
		返回_值.Cqpzr_重切片载入(当前值)
		return
	default:
		//返回_错误 = errors.New("错误:被取值的类型不是[]any")
		return
	}
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Qzjj_取字节集(路径或索引 string, 索引 ...string) (返回_值 []byte) {
	值, 返回_错误 := 键值类.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case []byte:
		返回_值 = 当前值
		return
	default:
		文本值 := any_到文本(当前值)
		返回_值 = []byte(文本值)
		return
	}
}
func (键值类 *Jzb_键值表) Qsjrq_取时间日期(路径或索引 string, 索引 ...string) (返回_值 time.Time) {
	值, 返回_错误 := 键值类.Qz_取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case time.Time:
		返回_值 = 当前值
		return
	default:
		文本值 := any_到文本(当前值)
		返回_值, _ = time.Parse("2006-01-02 15:04:05", 文本值)
		return
	}
}

func (键值类 *Jzb_键值表) Qsl_取数量() int {
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.RLock()
		defer 键值类.读写许可.RUnlock()
	}
	return len(键值类.原始数据)
}

// @ 1为升序 2为降序 空 或者 其它为不排序
func (键值类 *Jzb_键值表) Qjsz_取键数组(排序方式 ...int) []string {
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.RLock()
		defer 键值类.读写许可.RUnlock()
	}
	jc := 0
	键组 := make([]string, len(键值类.原始数据))
	for k := range 键值类.原始数据 {
		键组[jc] = k
		jc++
	}
	if len(排序方式) == 0 {
		return 键组
	} else if 排序方式[0] == 1 {
		sort.Strings(键组)
	} else if 排序方式[0] == 2 {
		sort.Sort(sort.Reverse(sort.StringSlice(键组)))
	}
	return 键组
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Zz_置值(添加值 any, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	if 新值, ok := 添加值.(Jzb_键值表); ok {
		添加值 = 新值.Dmap_到map()
	} else if 新值, ok := 添加值.(Lb_列表); ok {
		添加值 = 新值.Dqp_到切片()
	}

	返回_错误 = 切片和map值类型筛选(添加值)
	if 返回_错误 != nil {
		return
	}
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.Lock()
		defer 键值类.读写许可.Unlock()
	}
	路径 := ""
	if len(索引) > 0 {
		路径 = 路径或索引 + "." + strings.Join(索引, ".")
	} else {
		路径 = 路径或索引
	}
	路径组 := q_切片和map路径分割(路径)
	if len(路径组) == 0 {
		返回_错误 = errors.New("错误:路径解析错误,路径不能为空")
		return
	}
	返回_错误 = q_切片和map置值(键值类.原始数据, 路径组, 添加值)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Zqptj_子切片添加(添加值 any, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	if 新值, ok := 添加值.(Jzb_键值表); ok {
		添加值 = 新值.Dmap_到map()
	} else if 新值, ok := 添加值.(Lb_列表); ok {
		添加值 = 新值.Dqp_到切片()
	}
	返回_错误 = 切片和map值类型筛选(添加值)
	if 返回_错误 != nil {
		return
	}
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.Lock()
		defer 键值类.读写许可.Unlock()
	}
	路径 := ""
	if len(索引) > 0 {
		路径 = 路径或索引 + "." + strings.Join(索引, ".")
	} else {
		路径 = 路径或索引
	}
	路径组 := q_切片和map路径分割(路径)
	if len(路径组) == 0 {
		返回_错误 = errors.New("错误:路径解析错误,路径不能为空")
		return
	}
	返回_错误 = q_切片和map子切片添加值(键值类.原始数据, 路径组, 添加值)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Zwb_置文本(添加值, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 键值类.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Zzs_置整数(添加值 int, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 键值类.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Zsjdxs_置双精度小数(添加值 float64, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 键值类.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Zlj_置逻辑(添加值 bool, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 键值类.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Zzjj_置字节集(添加值 []byte, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 键值类.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Zsjrq_置时间日期(添加值 time.Time, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 键值类.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Zmap_置map(添加值 map[string]any, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 键值类.Zz_置值(添加值, 路径或索引, 索引...)
	return
}
func (键值类 *Jzb_键值表) Zjzb_置键值表(添加值 Jzb_键值表, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 键值类.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (键值类 *Jzb_键值表) Zqp_置切片(添加值 []any, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 键值类.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

func (键值类 *Jzb_键值表) Zlb_置列表(添加值 Lb_列表, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 键值类.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割 但 不分割 ” 和 "" 内的 . 自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.['路径2'].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
// 自动会把 []map[string]any 转换成 []any
func (键值类 *Jzb_键值表) Zqpmapz_置切片map组(添加值 []map[string]any, 路径或索引 string, 索引 ...string) (返回_错误 error) {
	返回_错误 = 键值类.Zz_置值(添加值, 路径或索引, 索引...)
	return
}

func (键值类 *Jzb_键值表) Scz_删除值(路径或索引 string, 索引 ...string) (返回_错误 error) {
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.Lock()
		defer 键值类.读写许可.Unlock()
	}
	路径 := ""
	if len(索引) > 0 {
		路径 = 路径或索引 + "." + strings.Join(索引, ".")
	} else {
		路径 = 路径或索引
	}
	路径组 := q_切片和map路径分割(路径)
	if len(路径组) == 0 {
		返回_错误 = errors.New("错误:路径解析错误,路径不能为空")
		return
	}
	if len(键值类.原始数据) == 0 {
		键值类.原始数据 = make(map[string]any)
	}

	返回值,返回_错误 := q_切片和map删除值(键值类.原始数据, 路径组)
	if  值,ok:=返回值.(map[string]any);ok &&返回_错误==nil{
		键值类.原始数据=值
	}
	return
}
func (键值类 *Jzb_键值表) Cwjzr_重文件载入(文件路径 string) (返回_错误 error) {
	var data []byte
	data, 返回_错误 = os.ReadFile(文件路径)
	if 返回_错误 != nil {
		return
	}
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.Lock()
		defer 键值类.读写许可.Unlock()
	}
	返回_错误 = json.Unmarshal(data, &键值类.原始数据)
	if 返回_错误 != nil {
		return
	}
	return
}

func (键值类 *Jzb_键值表) Bcdwj_保存到文件(文件路径 string) (返回_错误 error) {
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.RLock()
		defer 键值类.读写许可.RUnlock()
	}
	转换表 := 切片和map深拷贝json前byte组处理(键值类.原始数据)
	JSON, err := json.Marshal(转换表)
	if err != nil {
		返回_错误 = err
		return
	}
	返回_错误 = os.WriteFile(文件路径, []byte(JSON), os.ModePerm)
	return
}

// 只支 判断持首层键
func (键值类 *Jzb_键值表) Pdjsfcz_判断_键是否存在(键名称 string) (返回_值 bool) {
	键值类.初始化map()
	if 键值类.读写许可 != nil {
		键值类.读写许可.RLock()
		defer 键值类.读写许可.RUnlock()
	}
	_, 返回_值 = 键值类.原始数据[键名称]
	return
}
